// import com.alibaba.druid.sql.SQLUtils;
// import com.alibaba.druid.wall.spi.WallVisitorUtils;

// import java.util.*;
// import java.util.concurrent.ConcurrentSkipListSet;

// import static com.alibaba.druid.util.Utils.getBoolean;
// import static com.alibaba.druid.util.Utils.getInteger;
// import static com.alibaba.druid.wall.spi.WallVisitorUtils.loadResource;
#pragma once
#include "WallConfigMBean.h"

class WallConfig :virtual public WallConfigMBean {
public:
    // bool noneBaseStatementAllow;

    // bool callAllow = true;
    // bool selelctAllow = true;
    // bool selectIntoAllow = true;
    // bool selectIntoOutfileAllow;
    // bool selectWhereAlwayTrueCheck = true;
    // bool selectHavingAlwayTrueCheck = true;
    // bool selectUnionCheck = true;
    // bool selectMinusCheck = true;
    // bool selectExceptCheck = true;
    // bool selectIntersectCheck = true;
    // bool createTableAllow = true;
    // bool dropTableAllow = true;
    // bool alterTableAllow = true;
    // bool renameTableAllow = true;
    // bool hintAllow = true;
    // bool lockTableAllow = true;
    // bool startTransactionAllow = true;
    // bool blockAllow = true;

    // bool conditionAndAlwayTrueAllow;
    // bool conditionAndAlwayFalseAllow;
    // bool conditionDoubleConstAllow;
    bool conditionLikeTrueAllow;

    // bool selectAllColumnAllow = true;

    // bool deleteAllow = true;
    // bool deleteWhereAlwayTrueCheck = true;
    // bool deleteWhereNoneCheck;

    // bool updateAllow = true;
    // bool updateWhereAlayTrueCheck = true;
    // bool updateWhereNoneCheck;

    // bool insertAllow = true;
    // bool mergeAllow = true;
    // bool minusAllow = true;
    // bool intersectAllow = true;
    // bool replaceAllow = true;
    // bool setAllow = true;
    // bool commitAllow = true;
    // bool rollbackAllow = true;
    // bool useAllow = true;

    // bool multiStatementAllow;

    // bool truncateAllow = true;

    // bool commentAllow;
    // bool strictSyntaxCheck = true;
    // bool constArithmeticAllow = true;
    // bool limitZeroAllow;

    // bool describeAllow = true;
    // bool showAllow = true;

    // bool schemaCheck = true;
    // bool tableCheck = true;
    // bool functionCheck = true;
    // bool objectCheck = true;
    // bool variantCheck = true;

    // bool mustParameterized;

    // bool doPrivilegedAllow;

    // protected final Set<String> denyFunctions = new ConcurrentSkipListSet<String>();
    // protected final Set<String> denyTables = new ConcurrentSkipListSet<String>();
    // protected final Set<String> denySchemas = new ConcurrentSkipListSet<String>();
    // protected final Set<String> denyVariants = new ConcurrentSkipListSet<String>();
    // protected final Set<String> denyObjects = new ConcurrentSkipListSet<String>();

    // protected final Set<String> permitFunctions = new ConcurrentSkipListSet<String>();
    // protected final Set<String> permitTables = new ConcurrentSkipListSet<String>();
    // protected final Set<String> permitSchemas = new ConcurrentSkipListSet<String>();
    // protected final Set<String> permitVariants = new ConcurrentSkipListSet<String>();

    // protected final Set<String> readOnlyTables = new ConcurrentSkipListSet<String>();

    // String dir;

    // bool inited;

    // String tenantTablePattern;
    // String tenantColumn;
    // TenantCallBack tenantCallBack;

    // bool wrapAllow = true;
    // bool metadataAllow = true;

    // bool conditionOpXorAllow;
    // bool conditionOpBitwseAllow = true;

    bool caseConditionConstAllow;

    // bool completeInsertValuesCheck;
    // int insertValuesCheckSize = 3;

    // int selectLimit = -1;

    // protected Map<String, Set<String>> updateCheckColumns = new HashMap<String, Set<String>>();
    // protected WallUpdateCheckHandler updateCheckHandler;

    WallConfig() {
        // this->configFromProperties(System.getProperties());
    conditionLikeTrueAllow=true;
    }

    bool isCaseConditionConstAllow() {
        return caseConditionConstAllow;
    }

    void setCaseConditionConstAllow(bool caseConditionConstAllow) {
        this->caseConditionConstAllow = caseConditionConstAllow;
    }

    // bool isConditionDoubleConstAllow() {
    //     return conditionDoubleConstAllow;
    // }

    // void setConditionDoubleConstAllow(bool conditionDoubleConstAllow) {
    //     this->conditionDoubleConstAllow = conditionDoubleConstAllow;
    // }

    bool isConditionLikeTrueAllow() {
        return conditionLikeTrueAllow;
    }

    void setConditionLikeTrueAllow(bool conditionLikeTrueAllow) {
        this->conditionLikeTrueAllow = conditionLikeTrueAllow;
    }

    // bool isLimitZeroAllow() {
    //     return limitZeroAllow;
    // }

    // void setLimitZeroAllow(bool limitZero) {
    //     this->limitZeroAllow = limitZero;
    // }

    // bool isUseAllow() {
    //     return useAllow;
    // }

    // void setUseAllow(bool useAllow) {
    //     this->useAllow = useAllow;
    // }

    // bool isCommitAllow() {
    //     return commitAllow;
    // }

    // void setCommitAllow(bool commitAllow) {
    //     this->commitAllow = commitAllow;
    // }

    // bool isRollbackAllow() {
    //     return rollbackAllow;
    // }

    // void setRollbackAllow(bool rollbackAllow) {
    //     this->rollbackAllow = rollbackAllow;
    // }

    // bool isIntersectAllow() {
    //     return intersectAllow;
    // }

    // void setIntersectAllow(bool intersectAllow) {
    //     this->intersectAllow = intersectAllow;
    // }

    // bool isMinusAllow() {
    //     return minusAllow;
    // }

    // void setMinusAllow(bool minusAllow) {
    //     this->minusAllow = minusAllow;
    // }

    // bool isConditionOpXorAllow() {
    //     return conditionOpXorAllow;
    // }

    // void setConditionOpXorAllow(bool conditionOpXorAllow) {
    //     this->conditionOpXorAllow = conditionOpXorAllow;
    // }

    // String getTenantTablePattern() {
    //     return tenantTablePattern;
    // }

    // void setTenantTablePattern(String tenantTablePattern) {
    //     this->tenantTablePattern = tenantTablePattern;
    // }

    // String getTenantColumn() {
    //     return tenantColumn;
    // }

    // void setTenantColumn(String tenantColumn) {
    //     this->tenantColumn = tenantColumn;
    // }

    // TenantCallBack getTenantCallBack() {
    //     return tenantCallBack;
    // }

    // void setTenantCallBack(TenantCallBack tenantCallBack) {
    //     this->tenantCallBack = tenantCallBack;
    // }

    // bool isMetadataAllow() {
    //     return metadataAllow;
    // }

    // void setMetadataAllow(bool metadataAllow) {
    //     this->metadataAllow = metadataAllow;
    // }

    // bool isWrapAllow() {
    //     return wrapAllow;
    // }

    // void setWrapAllow(bool wrapAllow) {
    //     this->wrapAllow = wrapAllow;
    // }

    // bool isDoPrivilegedAllow() {
    //     return doPrivilegedAllow;
    // }

    // void setDoPrivilegedAllow(bool doPrivilegedAllow) {
    //     this->doPrivilegedAllow = doPrivilegedAllow;
    // }

    // bool isSelectAllColumnAllow() {
    //     return selectAllColumnAllow;
    // }

    // void setSelectAllColumnAllow(bool selectAllColumnAllow) {
    //     this->selectAllColumnAllow = selectAllColumnAllow;
    // }

    // bool isInited() {
    //     return inited;
    // }

    // WallConfig(String dir) {
    //     this();
    //     this->dir = dir;
    //     this->init();
    // }

    // String getDir() {
    //     return dir;
    // }

    // void setDir(String dir) {
    //     this->dir = dir;
    // }

    // final void init() {
    //     loadConfig(dir);
    // }

    // void loadConfig(String dir) {
    //     if (dir.endsWith("/")) {
    //         dir = dir.substring(0, dir.length() - 1);
    //     }

    //     loadResource(this->denyVariants, dir + "/deny-variant.txt");
    //     loadResource(this->denySchemas, dir + "/deny-schema.txt");
    //     loadResource(this->denyFunctions, dir + "/deny-function.txt");
    //     loadResource(this->denyTables, dir + "/deny-table.txt");
    //     loadResource(this->denyObjects, dir + "/deny-object.txt");
    //     loadResource(this->readOnlyTables, dir + "/readonly-table.txt");

    //     loadResource(this->permitFunctions, dir + "/permit-function.txt");
    //     loadResource(this->permitTables, dir + "/permit-table.txt");
    //     loadResource(this->permitSchemas, dir + "/permit-schema.txt");
    //     loadResource(this->permitVariants, dir + "/permit-variant.txt");
    // }

    // bool isNoneBaseStatementAllow() {
    //     return noneBaseStatementAllow;
    // }

    // void setNoneBaseStatementAllow(bool noneBaseStatementAllow) {
    //     this->noneBaseStatementAllow = noneBaseStatementAllow;
    // }

    // /**
    //  * allow mysql describe statement
    //  *
    //  * @return
    //  * @since 0.2.10
    //  */
    // bool isDescribeAllow() {
    //     return describeAllow;
    // }

    // /**
    //  * set allow mysql describe statement
    //  *
    //  * @since 0.2.10
    //  */
    // void setDescribeAllow(bool describeAllow) {
    //     this->describeAllow = describeAllow;
    // }

    // bool isShowAllow() {
    //     return showAllow;
    // }

    // void setShowAllow(bool showAllow) {
    //     this->showAllow = showAllow;
    // }

    // bool isTruncateAllow() {
    //     return truncateAllow;
    // }

    // void setTruncateAllow(bool truncateAllow) {
    //     this->truncateAllow = truncateAllow;
    // }

    // bool isSelectIntoAllow() {
    //     return selectIntoAllow;
    // }

    // void setSelectIntoAllow(bool selectIntoAllow) {
    //     this->selectIntoAllow = selectIntoAllow;
    // }

    // bool isSelectIntoOutfileAllow() {
    //     return selectIntoOutfileAllow;
    // }

    // void setSelectIntoOutfileAllow(bool selectIntoOutfileAllow) {
    //     this->selectIntoOutfileAllow = selectIntoOutfileAllow;
    // }

    // bool isCreateTableAllow() {
    //     return createTableAllow;
    // }

    // void setCreateTableAllow(bool createTableAllow) {
    //     this->createTableAllow = createTableAllow;
    // }

    // bool isDropTableAllow() {
    //     return dropTableAllow;
    // }

    // void setDropTableAllow(bool dropTableAllow) {
    //     this->dropTableAllow = dropTableAllow;
    // }

    // bool isAlterTableAllow() {
    //     return alterTableAllow;
    // }

    // void setAlterTableAllow(bool alterTableAllow) {
    //     this->alterTableAllow = alterTableAllow;
    // }

    // bool isRenameTableAllow() {
    //     return renameTableAllow;
    // }

    // void setRenameTableAllow(bool renameTableAllow) {
    //     this->renameTableAllow = renameTableAllow;
    // }

    // bool isSelectUnionCheck() {
    //     return selectUnionCheck;
    // }

    // void setSelectUnionCheck(bool selectUnionCheck) {
    //     this->selectUnionCheck = selectUnionCheck;
    // }

    // bool isSelectMinusCheck() {
    //     return selectMinusCheck;
    // }

    // void setSelectMinusCheck(bool selectMinusCheck) {
    //     this->selectMinusCheck = selectMinusCheck;
    // }

    // bool isSelectExceptCheck() {
    //     return selectExceptCheck;
    // }

    // void setSelectExceptCheck(bool selectExceptCheck) {
    //     this->selectExceptCheck = selectExceptCheck;
    // }

    // bool isSelectIntersectCheck() {
    //     return selectIntersectCheck;
    // }

    // void setSelectIntersectCheck(bool selectIntersectCheck) {
    //     this->selectIntersectCheck = selectIntersectCheck;
    // }

    // bool isDeleteAllow() {
    //     return deleteAllow;
    // }

    // void setDeleteAllow(bool deleteAllow) {
    //     this->deleteAllow = deleteAllow;
    // }

    // bool isDeleteWhereNoneCheck() {
    //     return deleteWhereNoneCheck;
    // }

    // void setDeleteWhereNoneCheck(bool deleteWhereNoneCheck) {
    //     this->deleteWhereNoneCheck = deleteWhereNoneCheck;
    // }

    // bool isUpdateAllow() {
    //     return updateAllow;
    // }

    // void setUpdateAllow(bool updateAllow) {
    //     this->updateAllow = updateAllow;
    // }

    // bool isUpdateWhereNoneCheck() {
    //     return updateWhereNoneCheck;
    // }

    // void setUpdateWhereNoneCheck(bool updateWhereNoneCheck) {
    //     this->updateWhereNoneCheck = updateWhereNoneCheck;
    // }

    // bool isInsertAllow() {
    //     return insertAllow;
    // }

    // void setInsertAllow(bool insertAllow) {
    //     this->insertAllow = insertAllow;
    // }

    // bool isReplaceAllow() {
    //     return replaceAllow;
    // }

    // void setReplaceAllow(bool replaceAllow) {
    //     this->replaceAllow = replaceAllow;
    // }

    // bool isSetAllow() {
    //     return setAllow;
    // }

    // void setSetAllow(bool value) {
    //     this->setAllow = value;
    // }

    // bool isMergeAllow() {
    //     return mergeAllow;
    // }

    // void setMergeAllow(bool mergeAllow) {
    //     this->mergeAllow = mergeAllow;
    // }

    // bool isMultiStatementAllow() {
    //     return multiStatementAllow;
    // }

    // void setMultiStatementAllow(bool multiStatementAllow) {
    //     this->multiStatementAllow = multiStatementAllow;
    // }

    // bool isSchemaCheck() {
    //     return schemaCheck;
    // }

    // void setSchemaCheck(bool schemaCheck) {
    //     this->schemaCheck = schemaCheck;
    // }

    // bool isTableCheck() {
    //     return tableCheck;
    // }

    // void setTableCheck(bool tableCheck) {
    //     this->tableCheck = tableCheck;
    // }

    // bool isFunctionCheck() {
    //     return functionCheck;
    // }

    // void setFunctionCheck(bool functionCheck) {
    //     this->functionCheck = functionCheck;
    // }

    // bool isVariantCheck() {
    //     return variantCheck;
    // }

    // void setVariantCheck(bool variantCheck) {
    //     this->variantCheck = variantCheck;
    // }

    // bool isObjectCheck() {
    //     return objectCheck;
    // }

    // void setObjectCheck(bool objectCheck) {
    //     this->objectCheck = objectCheck;
    // }

    // // ///////////////////

    // bool isCommentAllow() {
    //     return commentAllow;
    // }

    // void setCommentAllow(bool commentAllow) {
    //     this->commentAllow = commentAllow;
    // }

    // bool isStrictSyntaxCheck() {
    //     return strictSyntaxCheck;
    // }

    // void setStrictSyntaxCheck(bool strictSyntaxCheck) {
    //     this->strictSyntaxCheck = strictSyntaxCheck;
    // }

    // bool isConstArithmeticAllow() {
    //     return constArithmeticAllow;
    // }

    // void setConstArithmeticAllow(bool constArithmeticAllow) {
    //     this->constArithmeticAllow = constArithmeticAllow;
    // }

    // Set<String> getDenyFunctions() {
    //     return denyFunctions;
    // }

    // Set<String> getDenyTables() {
    //     return denyTables;
    // }

    // Set<String> getDenySchemas() {
    //     return denySchemas;
    // }

    // Set<String> getDenyVariants() {
    //     return denyVariants;
    // }

    // Set<String> getDenyObjects() {
    //     return denyObjects;
    // }

    // Set<String> getReadOnlyTables() {
    //     return readOnlyTables;
    // }

    // void addReadOnlyTable(String tableName) {
    //     this->readOnlyTables.add(tableName);
    // }

    // bool isReadOnly(String tableName) {
    //     return this->readOnlyTables.contains(tableName);
    // }

    // Set<String> getPermitFunctions() {
    //     return permitFunctions;
    // }

    // Set<String> getPermitTables() {
    //     return permitTables;
    // }

    // Set<String> getPermitSchemas() {
    //     return permitSchemas;
    // }

    // Set<String> getPermitVariants() {
    //     return permitVariants;
    // }

    // bool isMustParameterized() {
    //     return mustParameterized;
    // }

    // void setMustParameterized(bool mustParameterized) {
    //     this->mustParameterized = mustParameterized;
    // }

    // bool isDenyObjects(String name) {
    //     if (!objectCheck) {
    //         return false;
    //     }

    //     name = WallVisitorUtils.form(name);
    //     return denyObjects.contains(name);
    // }

    // bool isDenySchema(String name) {
    //     if (!schemaCheck) {
    //         return false;
    //     }

    //     name = WallVisitorUtils.form(name);
    //     return this->denySchemas.contains(name);
    // }

    // bool isDenyFunction(String name) {
    //     if (!functionCheck) {
    //         return false;
    //     }

    //     name = WallVisitorUtils.form(name);
    //     return this->denyFunctions.contains(name);
    // }

    // bool isCallAllow() {
    //     return callAllow;
    // }

    // void setCallAllow(bool callAllow) {
    //     this->callAllow = callAllow;
    // }

    // bool isHintAllow() {
    //     return hintAllow;
    // }

    // void setHintAllow(bool hintAllow) {
    //     this->hintAllow = hintAllow;
    // }

    // interface TenantCallBack {
    //     static enum StatementType {
    //         SELECT, UPDATE, INSERT, DELETE
    //     }

    //     Object getTenantValue(StatementType statementType, String tableName);

    //     String getTenantColumn(StatementType statementType, String tableName);

    //     /**
    //      * 返回resultset隐藏列名
    //      *
    //      * @param tableName
    //      */
    //     String getHiddenColumn(String tableName);

    //     /**
    //      * resultset返回值中如果包含tenantColumn的回调函数
    //      *
    //      * @param value tenantColumn对应的值
    //      */
    //     void filterResultsetTenantColumn(Object value);
    // }

    // bool isSelectAllow() {
    //     return selelctAllow;
    // }

    // void setSelectAllow(bool selelctAllow) {
    //     this->selelctAllow = selelctAllow;
    // }

    // /**
    //  * @deprecated use isSelectAllow
    //  */
    // bool isSelelctAllow() {
    //     return isSelectAllow();
    // }

    // /**
    //  * @deprecated use setSelelctAllow
    //  */
    // void setSelelctAllow(bool selelctAllow) {
    //     this->setSelectAllow(selelctAllow);
    // }

    // bool isSelectWhereAlwayTrueCheck() {
    //     return selectWhereAlwayTrueCheck;
    // }

    // void setSelectWhereAlwayTrueCheck(bool selectWhereAlwayTrueCheck) {
    //     this->selectWhereAlwayTrueCheck = selectWhereAlwayTrueCheck;
    // }

    // bool isSelectHavingAlwayTrueCheck() {
    //     return selectHavingAlwayTrueCheck;
    // }

    // void setSelectHavingAlwayTrueCheck(bool selectHavingAlwayTrueCheck) {
    //     this->selectHavingAlwayTrueCheck = selectHavingAlwayTrueCheck;
    // }

    // bool isConditionAndAlwayTrueAllow() {
    //     return conditionAndAlwayTrueAllow;
    // }

    // void setConditionAndAlwayTrueAllow(bool conditionAndAlwayTrueAllow) {
    //     this->conditionAndAlwayTrueAllow = conditionAndAlwayTrueAllow;
    // }

    // bool isConditionAndAlwayFalseAllow() {
    //     return conditionAndAlwayFalseAllow;
    // }

    // void setConditionAndAlwayFalseAllow(bool conditionAndAlwayFalseAllow) {
    //     this->conditionAndAlwayFalseAllow = conditionAndAlwayFalseAllow;
    // }

    // bool isDeleteWhereAlwayTrueCheck() {
    //     return deleteWhereAlwayTrueCheck;
    // }

    // void setDeleteWhereAlwayTrueCheck(bool deleteWhereAlwayTrueCheck) {
    //     this->deleteWhereAlwayTrueCheck = deleteWhereAlwayTrueCheck;
    // }

    // bool isUpdateWhereAlayTrueCheck() {
    //     return updateWhereAlayTrueCheck;
    // }

    // void setUpdateWhereAlayTrueCheck(bool updateWhereAlayTrueCheck) {
    //     this->updateWhereAlayTrueCheck = updateWhereAlayTrueCheck;
    // }

    // bool isConditionOpBitwseAllow() {
    //     return conditionOpBitwseAllow;
    // }

    // void setConditionOpBitwseAllow(bool conditionOpBitwseAllow) {
    //     this->conditionOpBitwseAllow = conditionOpBitwseAllow;
    // }

    // void setInited(bool inited) {
    //     this->inited = inited;
    // }

    // bool isLockTableAllow() {
    //     return lockTableAllow;
    // }

    // void setLockTableAllow(bool lockTableAllow) {
    //     this->lockTableAllow = lockTableAllow;
    // }

    // bool isStartTransactionAllow() {
    //     return startTransactionAllow;
    // }

    // void setStartTransactionAllow(bool startTransactionAllow) {
    //     this->startTransactionAllow = startTransactionAllow;
    // }

    // bool isCompleteInsertValuesCheck() {
    //     return completeInsertValuesCheck;
    // }

    // void setCompleteInsertValuesCheck(bool completeInsertValuesCheck) {
    //     this->completeInsertValuesCheck = completeInsertValuesCheck;
    // }

    // int getInsertValuesCheckSize() {
    //     return insertValuesCheckSize;
    // }

    // void setInsertValuesCheckSize(int insertValuesCheckSize) {
    //     this->insertValuesCheckSize = insertValuesCheckSize;
    // }

    // bool isBlockAllow() {
    //     return blockAllow;
    // }

    // void setBlockAllow(bool blockAllow) {
    //     this->blockAllow = blockAllow;
    // }

    // int getSelectLimit() {
    //     return selectLimit;
    // }

    // void setSelectLimit(int selectLimit) {
    //     this->selectLimit = selectLimit;
    // }

    // void configFromProperties(Properties properties) {
    //     {
    //         String propertyValue = properties.getProperty("druid.wall.tenantColumn");
    //         if (propertyValue != null) {
    //             this->setTenantColumn(propertyValue);
    //         }
    //     }
    //     {
    //         Boolean propertyValue = getBoolean(properties, "druid.wall.selelctAllow");
    //         if (propertyValue != null) {
    //             this->setSelectAllow(propertyValue);
    //         }
    //     }
    //     {
    //         Boolean propertyValue = getBoolean(properties, "druid.wall.updateAllow");
    //         if (propertyValue != null) {
    //             this->setUpdateAllow(propertyValue);
    //         }
    //     }
    //     {
    //         Boolean propertyValue = getBoolean(properties, "druid.wall.deleteAllow");
    //         if (propertyValue != null) {
    //             this->setDeleteAllow(propertyValue);
    //         }
    //     }
    //     {
    //         Boolean propertyValue = getBoolean(properties, "druid.wall.insertAllow");
    //         if (propertyValue != null) {
    //             this->setInsertAllow(propertyValue);
    //         }
    //     }
    //     {
    //         Boolean propertyValue = getBoolean(properties, "druid.wall.multiStatementAllow");
    //         if (propertyValue != null) {
    //             this->setMultiStatementAllow(propertyValue);
    //         }
    //     }
    //     {
    //         Integer propertyValue = getInteger(properties, "druid.wall.selectLimit");
    //         if (propertyValue != null) {
    //             this->setSelectLimit(propertyValue);
    //         }
    //     }
    //     {
    //         String propertyValue = properties.getProperty("druid.wall.updateCheckColumns");
    //         if (propertyValue != null) {
    //             String[] items = propertyValue.split(",");
    //             for (String item : items) {
    //                 addUpdateCheckCoumns(item);
    //             }
    //         }
    //     }
    //     {
    //         Boolean propertyValue = getBoolean(properties, "druid.wall.updateWhereNoneCheck");
    //         if (propertyValue != null) {
    //             this->setUpdateWhereNoneCheck(propertyValue);
    //         }
    //     }
    //     {
    //         Boolean propertyValue = getBoolean(properties, "druid.wall.deleteWhereNoneCheck");
    //         if (propertyValue != null) {
    //             this->setDeleteWhereNoneCheck(propertyValue);
    //         }
    //     }
    // }

    // void addUpdateCheckCoumns(String columnInfo) {
    //     String[] items = columnInfo.split("\\.");
    //     if (items.length != 2) {
    //         return;
    //     }
    //     String table = SQLUtils.normalize(items[0]).toLowerCase();
    //     String column = SQLUtils.normalize(items[1]).toLowerCase();
    //     Set<String> columns = this->updateCheckColumns.get(table);
    //     if (columns == null) {
    //         columns = new LinkedHashSet<String>();
    //         updateCheckColumns.put(table, columns);
    //     }
    //     columns.add(column);
    // }

    // bool isUpdateCheckTable(String tableName) {
    //     if (updateCheckColumns.isEmpty()) {
    //         return false;
    //     }
    //     String tableNameLower = SQLUtils.normalize(tableName).toLowerCase();
    //     return updateCheckColumns.containsKey(tableNameLower);
    // }

    // Set<String> getUpdateCheckTable(String tableName) {
    //     if (updateCheckColumns.isEmpty()) {
    //         return null;
    //     }
    //     String tableNameLower = SQLUtils.normalize(tableName).toLowerCase();
    //     return updateCheckColumns.get(tableNameLower);
    // }

    // WallUpdateCheckHandler getUpdateCheckHandler() {
    //     return updateCheckHandler;
    // }

    // void setUpdateCheckHandler(WallUpdateCheckHandler updateCheckHandler) {
    //     this->updateCheckHandler = updateCheckHandler;
    // }
};
